﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<string>
#include<cmath>
//1.求2个正整数或3个正整数中的最大值，用带有默认参数的函数实现
//void Fun(int a = 1, int b = 2, int c = 3)
//{
//	
//	
//	if (a < b)
//	{
//		a = b;
//	}
//	if (a < c)
//	{
//		a = c;
//	}
//	cout << a << endl;
//
//
//}
//int main()
//{
//	Fun(2, 7);
//
//	return 0;
//}

//默认参数（又叫缺省参数）
//默认参数必须是从右向左定义，不可跳跃定义
//void func(int a,int b = 10),b有默认值10

//输入两个整数，将它们按由大到小的顺序输出，要求使用变量的引用，并用函数调用的方式实现
//void Fun(int &a,int &b)//引用
//{
//	
//	if (a > b)
//		cout << a<<" " << b<<" " << endl;
//	else
//		cout << b<<" " << a<<" " << endl;
//	return;
//}
//int main()
//{
//	int x = 0;
//	int y = 0;
//	cin >> x >> y;
//	Fun(x,y);
//	return 0;
//}


//声明学生类包含学号、姓名、年龄，类体外定义成员函数input()用于输入对象的成员变量值，
// 成员函数change(int num, string name, int age)和show()用于修改值和输出各成员变量的值。
//class Student
//{
//public:
//	Student(int num, string name, int age)
//		:_num(num)
//		, _name(name)
//		, _age(age)
//	{
//	}
//	void change(int num, string name, int age)
//	{
//
//	}
//	void show(int num, string name, int age)
//	{
//		cout << num <<" " << name<<" " << age<<" " << endl;
//	}
//
//private:
//	int _num;
//	string _name;
//	int _age;
//};
//
//void input(int num, string name, int age)
//{
//	cin >> num >> name >> age;
//	return;
//}
//
//int main()
//{
//	Student d1;
//	input();
//	return 0;
//}
//下面是一个类的测试程序，设计出能使用如下测试程序的类。
// int main()
// {  
//  Test a;  
//  a.init(68,55);  
//  a.display();
// return 0;
// }
// 其执行结果为：68-55=13
//#include<iostream>
//using namespace std;

//class Test
//{
//public:
//	Test(int c = 68, int b = 55)
//		:_c(c)
//		,_b(b)
//	{}
//	int init(int _c,int _b)
//	{
//		return _c - _b;
//	}
//	void display()
//	{
//		int d = init(68,55);
//		cout <<_c<<"-"<<_b<< "=" <<d<< endl;
//	}
//private:
//	int _c ;
//	int _b;
//	int _d;
//};
//int main()
//{
//	Test a;
//	a.init(68, 55);
//	a.display();
//	return 0;
//}
//其执行结果为：68 - 55 = 13

//写出Time类的类声明及成员函数的实现。
// 要求：（1）在Time类中包含3个成员变量，即时（hour）、分（minute）和秒（second）。
// （2）声明定义类的构造函数与析构函数，构造函数为有默认值的构造函数，默认值以0时0分0秒为准，析构函数中输出“该对象被析构”。
// （3）定义一个成员函数Display()输出时间。
//class Time
//{
//public:
//	Time(int hour = 0,int minute = 0,int second = 0)
//		:_hour(hour)
//		, _minute(minute)
//		, _second(second)
//	{}
//	~Time()
//	{
//		cout << "该对象被析构" << endl;
//	}
//	void Display()
//	{
//		cout << _hour << ":" << _minute << ":" << _second << endl;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//int main()
//{
//	Time a;
//	a.Display();
//	Time b(2, 3, 4);
//	b.Display();
//	return 0;
//}
//写出Student类的类声明及成员函数的实现。
// 要求：（1）在Student类中包含4个成员变量，即学号（num）、姓名（name）、课程（course）和成绩（score）；
// （2）声明定义类的构造函数，构造函数为有默认值的构造函数；
// （3）定义一个成员函数display()输出信息；
// （4）在主函数中创建对象数组，并利用指向对象的指针去实现数组中各对象的输出。
//#include<iostream>
//using namespace std;
//#include<string>//
//class Student
//{
//public:
//    Student(int ID, string name, string classname, float score)
//        :_ID(ID)
//        , _name(name)
//        , _classname(classname)
//        , _score(score)
//    {}
//    static  void best(Student arr[], int size)//
//    {
//        float max = arr[0]._score;//初始化为第一个同学的分数
//        int maxIndex = 0;
//        for (int i = 1; i < size; i++)
//        {
//            if (max < arr[i]._score)
//            {
//                max = arr[i]._score;//方法内部应该有一个变量来记录最高分学生的索引
//                maxIndex = i;
//            }
//        }
//        cout << arr[maxIndex]._ID << arr[maxIndex]._name << arr[maxIndex]._classname << arr[maxIndex]._score << endl;
//    }
//private:
//    int _ID;
//    string _name;
//    string _classname;
//    float _score;
//};
//int main()
//{
//    Student arr[5]={Student(1, "yy", "yuwen", 89);Student(2, "aa", "yuwen", 96);Student(3, "jj", "yuwen", 84);Student(4, "rr", "yuwen", 78);Student(5, "pp", "yuwen", 68);};
//    Student* p = arr;
//    p->best(arr, 5);
//
//
//    return 0;
//}
//


//设计一个类圆Circle，通过成员函数求圆的面积和周长，并自定义合适的构造函数和析构函数。
//#define PI 3.1415
//#include<iostream>
//using namespace std;
//class Circle
//{
//public:
//	int s = 0;
//	int l = 0;
//	Circle(int r)
//		:_r(r)
//	{
//		s = PI * _r * _r;
//		l = 2 * PI * _r;
//		cout << s <<" " << l <<"  " << endl;
//	}
//	~Circle()
//	{
//		cout << "Circle以被析构";
//	}
//private:
//	int _r;
//};
//
//int main()
//{
//	Circle st(1);
//	return 0;
//}


//定义一个学生类，包含三个属性（学号，姓名，成绩）均为私有的，分别给这三个属性定义三个方法，
//一个构造函数设置它的值，一个成员函数输出它的值，一个析构函数输出“destructor a object” + 学号。
//创建3个学生类对象，进行功能测试
//class Student
//{
//public:
//	Student(int num, string name, float score)
//		:_num(num)
//		, _name(name)
//		, _score(score)
//	{
//	}
//	void Print()
//	{
//		cout << _num << " " << _name << " " << _score << endl;
//	}
//	~Student()
//	{
//		cout << "destructor a object" << " " << _num << endl;
//	}
//private:
//	int _num;
//	string _name;
//	float _score;
//};
//int main()
//{
//	Student st1(1, "yy", 56.0);
//	st1.Print();
//	Student st2(2, "ss", 56.4);
//	st2.Print();
//	Student st3(3, "hh", 70.0);
//	st3.Print();
//
//	
//
//	return 0;
//}

//设计一个学生类，包括学号、姓名、三门课成绩，计算每位学生平均成绩的成员函数以及构造函数和析构函数
//class Student
//{
//public:
//	Student(int num, string name, float yuwen, float shuxue, float yingyu)
//		:_num(num)
//		, _name(name)
//		, _yuwen(yuwen)
//		, _shuxue(shuxue)
//		, _yingyu(yingyu)
//	{
//
//	}
//	float sum = 0;
//	float average = 0;
//	void  Agerage()
//	{
//		sum = _yuwen + _shuxue + _yingyu;
//		average = sum / 3;
//		cout << average << endl;
//	}
//	~Student()
//	{
//		cout << "已析构";
//	}
//private:
//	int _num;
//	string _name;
//	float _yuwen;
//	float _shuxue;
//	float _yingyu;
//
//};
//int main()
//{
//	Student st1(1,"yy",56,86,98);
//	st1.Agerage();
//	return 0;
//}

//设计一个类Point，求两点之间的距离，类中需包括构造函数和析构函数（提示：可将成员变量设置成公有成员，数学函数#include <cmath>）
//sqrt 2次开根号函数，必须包含头文件#include <cmath>
//pow(2, 3) 将返回 2 的 3 次幂，即 8
//class Point
//{
//public:
//	double x;
//	double y;
//	Point(int m, int n)
//		:x(m)
//		,y(n)
//	{
//	}
//	~Point()
//	{
//		cout << "已析构"<<endl;
//	}
//	static double distance(Point &p1,Point &p2)
//	{
//		return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
//	}
//};
//int main()
//{
//	Point p1(4.0, 5.0);
//	Point p2(7.0, 9.0);
//   double d =	Point::distance(p1,p2);//错误写法：Point.distance();
//   cout<<d<<endl;
//	//1.调用时应该使用类名加上作用域解析运算符 ::，并且需要传入两个 Point 类型的参数，而代码中调用时没有传入参数。
//	return 0;
//}


//（1） 设计一个圆类circle和一个桌子类table，另设计一个圆桌类roundtable，它是从前两个类派生出来的。要求输出一个圆桌的高度，面积与颜色等
//class circle
//{
//public:
//	circle(int s)
//		:_s(s)
//	{
//	}
//	void show()
//	{
//		cout << _s << " " << endl;
//	}
//private:
//	int _s;
//};
//
//class table
//{
//public:
//	table(int high,string colour)
//		:_high(high)
//		,_colour(colour)
//	{}
//	void display()
//	{
//		cout << _high << " " << _colour << " " << endl;
//	}
//private:
//	int _high;
//	string _colour;
//};
//
//class roundtable :public circle, public table
//{
//public:
//     roundtable(double s,int high,string colour)
//		 :circle(s)
//		 ,table(high,colour)
//	 {}
//	 void Print()
//	 {
//		 show();
//		 display();
//	 }
//};
//
//int main()
//{
//	roundtable st1(40.0, 50, "huangshe");
//	st1.Print();
//	return 0;
//}
//
//

//（2）声明一个国家基类Country，包含国名、首都、人口等属性，派生出省类Province，增加省会城市、人口数量属性。定义派生类对象，并对相应信息进行输出。
//class country
//{
//public:
//	country(string countryname, string capital, int population)
//		:_countryname(countryname)
//		,_capital(capital)
//		,_population(population)
//	{}
//	void show()
//			{
//				cout << _countryname << " "<< _capital <<" " << _population << endl;
//			}
//
//private:
//	string _countryname;
//	string _capital;
//	int _population;
//};
//class Province :public country
//{
//public:
//	Province(string countryname, string capital, int population,string city,int Population)
//		: country(countryname, capital, population)
//		,_city(city)
//		, _Population(Population)
//	{}
//	void Print()
//			 {
//				 show();
//				 cout << _city << " " << _Population << endl;
//				 
//			 }
//	
//private:
//	string _city;
//	int _Population;
// };
//int main()
//{
//	Province st("中国", "北京", 14000000000, "湖北", 1300);
//	st.Print();
//	return 0;
//}



//编写程序模拟简单的计算器。
//定义名为Number的类其中有两个整型数据成员n1和n2应声明为私有。
//编写函数init赋予n1和n2初始值再为该类定义加addition、减subtration、乘multiplication、除division等公有成员方法分别对两个成员变量执行加、减、乘、除的运算。
//在main方法中创建Number类的对象调用各个方法并显示计算结果

//class Number
//{
//public:
//	
//	void init(int n1,int n2 )
//{
//		_n1 = n1;
//		_n2 = n2;
//
//}
//	int add()
//	{
//		return _n1 + _n2;
//	}
//	int sub()
//	{
//		return _n1 - _n2;
//	}
//	int mul()
//	{
//		return _n1 * _n2;
//	}
//	int div()
//	{
//		return _n1 / _n2;
//	}
//private:
//	int _n1;
//	int _n2;
//};
//
//
//int main()
//{
//	Number n;
//	n.init(4, 5);
//	int a = n.add();
//	cout << a << endl;
//	int b = n.sub();
//	cout << b << endl;
//
//	int c = n.mul();
//	cout << c << endl;
//
//	int d = n.div();
//	cout << d << endl;
//
//
//	return 0;
//}


//建立一个对象数组，内放5个学生的数据（学号、姓名、课程名称、成绩），一个学生对象只包含一门课程成绩，
//定义一个对象指针，指向学生数组，通过该指针调用函数输出最高分的学号、姓名、课程名称、成绩。
//class Student
//{
//public:
//	Student(string num, string name, string classname, double score)
//		:_num(num)
//		, _name(name)
//		, _classname(classname)
//		, _score(score)
//	{
//
//	}
//	void thebest(Student st[])
//	{
//		double max = st[0]._score;
//		int j = 0;
//		for (int i = 0; i < 5; i++)
//		{
//			if (st[i]._score > max)
//			{
//				max = st[i]._score;
//				j = i;
//			}
//		}
//		cout << st[j]._num << " " << st[j]._name << " " << st[j]._classname << " " << st[j]._score << endl;
//	}
//private:
//	string _num;
//	string _name;
//	string _classname;
//	double _score;
//};
//int main()
//{
//	Student st[5] = { {"1","yy","yuwen",89},{"2","mm","yuwen",93},{"3","pp","yuwen",66},{"4","ee","yuwen",77} ,{"5","tt","yuwen",90} };
//	st[0].thebest(st);
//	Student* p = st;
//	p->thebest(st);
//	return 0;
//}
// 

//8、编写程序，模拟银行账户功能。要求如下：属性：账号、储户姓名、地址、存款余额、最小余额（默认为100元）。
//方法：存款、取款、查询。根据用户操作显示储户相关信息。如存款操作后，显示储户原有余额、今日存款数额及最终存款余额；
//取款时，若最后余额小于最小余额，拒绝收款，并显示“至少保留余额XXX”，若最后余额大于最小余额，可以取款，但需保证取款后余额大于最小余额。
//class Account
//{
//public:
//	Account(string num, string name, string address, double balance)
//		:_num(num)
//		,_name(name)
//		,_address(address)
//		,_balance(balance)
//	{}
//	
//	void save()
//	{
//		string num1;
//		string name1;
//		double balance1;
//		cout << "请输入账号:" << endl;
//		cin >>num1 ;
//		cout << "请输入姓名:" << endl;
//		cin >> name1;
//		if (_num == num1 && _name == name1)
//		{
//			display();
//			cout << "今日存款数额：" << endl;
//			cin >> balance1;
//			_balance += balance1;
//			cout << "存款成功，总金额："<<_balance<< endl;
//		}
//	}
//	void get()
//	{
//		double balance1;
//		cout << "请输入取款金额："<<endl;
//		cin >> balance1;
//		if (_balance  < _minbalance)
//		{
//			cout << "拒绝收款" << endl;
//		}
//		else
//		{
//			if (_balance - balance1 > _minbalance)
//			{
//				_balance -= balance1;
//				cout << "取款成功" << endl;
//			}
//		}
//	}
//	void display()
//	{
//		cout << "您的余额是：" << _balance << endl;
//	}
//	private:
//	string _num;
//	string _name;
//	string _address;
//	double _balance;
//	static double _minbalance;
//};
//double Account::_minbalance = 100;
//int main()
//{
//	Account st("123","yy","whan",520.0);
//	st.display();
//	st.save();
//	st.get();
//	return 0;
//}

//在 C++ 中，std::string类重载了比较运算符（==、!=、<、>、<=、>=）。
//#include <iostream>
//#include <string>
//int main() {
//    std::string str1 = "hello";
//    std::string str2 = "world";
//    if (str1 < str2) {
//        std::cout << "str1小于str2\n";
//    }
//    else if (str1 > str2) {
//        std::cout << "str1大于str2\n";
//    }
//    else {
//        std::cout << "str1等于str2\n";
//    }
//    return 0;
//}

//1、在函数fn()中定义一个静态变量n，fn()中对n的值加1, 在主函数中调用fn函数10次并显示n的值。
//int fun()
//{
//	static int n = 0;
//	n += 1;
//	return n;
//}
//int main()
//{
//	static int n = 0;
//	int d = 0;
//	for (int i = 0; i < 10; i++)
//	{
//       d = fun();
//	}
//	cout << d << endl;
//
//	return 0;
//}
//3、定义一个Cat类，用静态成员变量num, 记录Cat 的个体数目; 静态成员函数getNum 读取num_的值。设计程序测试这个类，体会静态成员变量和静态成员函数的用法。。
//class Cat
//{
// public:
//	Cat()
//	{
//		_num++;
//	}
//	static int getNum()
//	{
//		return _num;
//	}
//private:
//	static int _num;
//};
//int Cat::_num = 0;
//int main()
//{
//	Cat s1;
//	Cat s2;
//	cout<<Cat::getNum();
//	
//	return 0;
//}
// 
// 
//4、设计一个学生类，包括学号、姓名、成绩总成(静态成员变量)，计算所有学生总成绩的静态成员函数及构造函数和析构函数。创建3个学生对象进行功能验证并求学生的平均成绩。。
// 
//class Student
//{
//public:
//	Student(string ID,string name,double score)
//		:_ID(ID)
//		,_name(name)
//		,_score(score)
//	{
//		_total_score += _score;
//		_count++;
//	}
//	static double Total()
//	{
//		return _total_score;
//	}
//	static double Average()
//	{
//		if (_count == 0)
//			return 0;
//		else
//		{
//			return _total_score / _count;
//		}
//	}
//	~Student()
//	{
//
//	}
//private:
//	string _ID;
//	string _name;
//	double _score;
//	
//	static double _total_score;
//	static int _count;
//};
//double Student::_total_score = 0;
//int Student::_count = 0;
//int main()
//{
//	Student st1("001", "张三", 85);
//	    Student st2("002", "李四", 90);
//	    Student st3("002", "王五", 80);
//		cout<<Student::Average();
//	return 0;
//}

//这道题目教会了我，第一：建立一个对象，就会有一次构造函数初始化，另外，我终于知道钩爪函数的那个小括号是用来干什么的了
//第二：目前你的get_score()函数被定义为静态成员函数，静态成员函数是属于类本身而不是类的某个具体对象的，它不能直接访问类的非静态成员（如_ID、_name、_score），因为它没有隐含的this指针指向某个具体对象。


//7、定义 Boat 与Car两个类，二者都有weight属性，定义二者的一个友元函数 getTotalWeight()，计算二者的重量和。
//class Car;
//class Boat
//{
//public:
//	Boat(double weight1)
//		:_weight1(weight1)
//	{}
//	friend double getTotalWeight(Boat& w1, Car& w2);
//
//private:
//	double _weight1;
//};
//class Car
//{
//public:
//	Car(double weight2)
//		:_weight2(weight2)
//	{}
//	friend double getTotalWeight(Boat& w1, Car& w2);
//private:
//	double _weight2;
//};
//
//double getTotalWeight(Boat&w1,Car&w2)
//{
//	return w1._weight1 + w2._weight2;
//}
//int main()
//{
//	Boat w1(40.0);
//	Car w2(40.0);
//	cout << getTotalWeight( w1, w2) << endl;
//	return 0;
//}

//这题的难点是传参，参考一下一般传参，另外，接收参数要么用指针，要么用引用，避免传值传参。


//
//2、建立一个基类Building类，用来存储楼房的层数、房间数和总面积，
// 由基类派生出教学楼TeachBuilding类和宿舍楼 DormBuilding类，
// 教学楼增加教室数, 
// 宿舍楼类增加宿舍数、容纳学生总人数。
// 编写程序，建立教学楼对象和宿舍楼对象，并输出它们的有关数据信息。
// 
//class Building
//{
//public:
//	Building(int floor, int room, double area)
//		: _floor(floor)
//		, _room(room)
//		, _area(area)
//	{
//
//	}
//	void show()
//	{
//		cout << _floor <<" " << _room<<" " << _area<<" " << endl;
//	}
//private:
//	int _floor;
//	int _room;
//	double _area;
//
//};
//class TeachBuilding :public  Building
//{
//public:
//	TeachBuilding(int classroom, int floor, int room, double area)
//		: Building(floor,  room,  area)
//		,_classroom(classroom)
//	{}
//	void display()
//	{
//	    show();
//		cout << _classroom << endl;
//	}
//private:
//	int _classroom;
//};
//class DormBuilding :public  Building
//{
//public:
//	DormBuilding(int floor, int room, double area, int dorm, int student)
//		:Building(floor, room, area)
//		, _dorm(dorm)
//		, _student(student)
//	{
//
//	}
//	void ppt()
//	{
//		 show();
//		cout << _dorm <<" " << _student<<" " << endl;
//	}
//private:
//	int _dorm;
//	int _student;
//};
//int main()
//{
//	TeachBuilding st(89,5600.0,56,420);
//	st.display();
//	DormBuilding st1(7,52,8555.0,32,330);
//	st1.ppt();
//	return 0;
//}

//1.已知类如下：
//（1）声明圆类。
//（2）声明基类圆的派生类：球，圆柱。
//要求：
//（1）根据题目后续要求定义相应的成员变量完成编程：
//（2）定义派生类球，圆柱的求表面积和体积的成员函数和输出函数
//（3）在主函数中分别输入相应的值计算球，圆柱的表面积并输出结果
//通常我们会引入 <cmath> 头文件来使用预定义的 M_PI 常量表示圆周率
//const double PI = M_PI;
//const double PI = M_PI;
//#define PI 3.1415
//class circle
//{
//public:
//	circle(double r)
//		:_r(r)
//	{}
//	
////private:
//	double _r;
//	static double _S;
//	static double _V;
//};
//double circle::_S = 0;
//double circle::_V = 0;
//class globe:public circle
//{
//public:
//	globe(double r)
//		:circle(r)
//	{}
//	void areavolume()
//	{
//		circle::_S = 4 * PI * _r * _r;
//		circle::_V = 4 / 3 * PI * _r * _r * _r;
//		cout << _S << " " << _V << endl;
//	}
//
//};
//
// class cylinder:public circle
// {
// public:
//	 cylinder(double r, double h)
//		 :circle(r)
//		 , _h(h)
//	 {
//	 }
//	 void av()
//	 {
//		circle:: _S = 2 * PI *_r * _r + 2 * PI * _r * _h;
//		circle:: _V = PI * _r * _r * _h;
//		cout << _S << " " << _V << endl;
//	 }
// private:
//	 double _h;
// };
//int main()
//{
//	circle s(2.0);
//	globe st1(1.2);
	/*cylinder st2(3.2, 7.0);
	st1.areavolume() ;
	 st2.av();

	return 0;
}*/

//已知类如下：
//（1）建立一个基类Account, 成员变量包括账号accnumber, 姓名accname;
//(2)从Account类派生出CreditAccount类，添加成员变量信用额度credit.
//要求：
//（1）Acount类包括默认构造函数，带参构造函数用于初始化成员变量和输出成员变量的函数。
//（2）CreditAccount类包括带参构造函数用于初始化成员变量和输出账户信息的成员函数。
//class Account
//{
//public:
//	Account(string accnumber = "q", string name = "f")
//		:_accnumber(accnumber)
//		,_name(name)
//	{
//		cout << _accnumber <<" " << _name<<" " << endl;
//	}
//private:
//	string _accnumber;
//	string _name;
//};
//class CreditAccount:public Account
//{
//public:
//	CreditAccount(double credit, string accnumber , string name)
//		:_credit(credit)
//		,Account(accnumber,name)
//	{
//		cout << _credit << endl;
//	}
//private:
//	double _credit;
//};
//int main()
//{
//	Account st1("555", "yy");
//	CreditAccount st2(563.0,"555","yy");
//		
//	return 0;
//}
//class Student
//{
//public:
//	Student(string num,string name,int age)
//		:_num(num)
//		,_name(name)
//		,_age(age)
//	{}
//	void display()
//	{
//		cout << _num << " " << _name << " " << _age;
//	}
//private:
//	string _num;
//	string _name;
//	int _age;
//};
//class Teacher
//{
//public:
//	Teacher(string tnum, string tname, string department)
//		:_tnum(tnum)
//		,_tname(tname)
//		,_department(department)
//	{
//
//	}
//	void show()
//	{
//		cout << _tnum << " " << _tname << endl;
//	}
//private:
//	string _tnum;
//	string _tname;
//	string _department;
//};
//
//class GradOnWork:public Student,public Teacher
//{
//public:
//	GradOnWork(string direction,string teacher, string num, string name, int age, string tnum, string tname, string department)
//		:_direction(direction)
//		,_teacher(teacher)
//		,Student(num,name,age)
//		,Teacher(tnum,tname,department)
//	{
//		display();
//		show();
//		cout << _direction << _teacher << endl;
//	}
//private:
//	string _direction;
//	string _teacher;
//};
//int main()
//{
//	Student("13", "yy", 12);
//	Teacher("56", "hh", "yyu");
//
//	GradOnWork gdonwk("ls","cl", "13", "yy", 12, "56", "hh", "yyu");
//	return 0;
//}

//抽象类+纯虚函数
//1.继承关系
//2.纯虚函数重写
//3.父类指针指向子类对象
// 
// 
//2、某学校教师每月工资的计算公式如下:固定工资 + 课时补贴。教授的固定工资为5000元，每个课时补贴50元; 副教授的固定工资为3000元，每个课时补贴30元; 
// 讲师的固定工资为2000元，每个课时补贴 20元。定义教师抽象类，派生不同职称的教师子类，编写程序求若干教师的月工资。
//class Professor
//{
//public:
//	virtual double get() = 0;
//
//};
//class professor:public Professor
//{
//public:
//	professor(int hour)
//		:_hour(hour)
//	{}
//
//	double get()
//	{
//		return _fixed + _hour * 50;
//	}
//private:
//	int _hour;
//	static int _fixed;
//};
//int professor::_fixed = 5000;
//class associatedprofessor:public Professor
//{
//public:
//	associatedprofessor(int hour1)
//		: _hour1(hour1)
//	{}
//
//	double get()
//	{
//		return _fixed1 + _hour1 * 30;
//	}
//private:
//	int _hour1;
//	static int _fixed1;
//};
//int associatedprofessor::_fixed1 = 3000;
//
//class temporarilyprofessor:public Professor
//{
//public:
//	temporarilyprofessor( int hour2)
//		:_hour2(hour2)
//	{}
//
//	double get()
//	{
//		return _fixed2 + _hour2 * 20;
//	}
//private:
//	int _hour2;
//	static int _fixed2;
//};
//int temporarilyprofessor::_fixed2 = 3000;
//
//int main()
//{
//	professor st(10);
//	cout << st.get() << endl;
//
//	associatedprofessor st1(15);
//	cout << st1.get() << endl;
//
//	temporarilyprofessor st2(20);
//	cout << st2.get() << endl;
//
//	return 0;
//}
//3、设计立体图形类 SolidFigure 为抽象基类，包含3个纯虚函数，分别是 getsuperficialArea 计算表面积、getVolume 计算体积、showAll输出所有信息。"
//派生类Cuboid表示长方体类，增加3个属性(width表示长度height表示宽度、high表示高度)。
//派生类Sphere 表示球体类，增加1个属性(radius 表示半径)。
//const double PI = M_PI;
//const double PI = M_PI;

//class SolidFigure
//{
//public:
//	virtual double getsuperficialArea() = 0;
//	virtual double getVolume() = 0;
//	virtual void showAll() = 0;
//};
//class Cuboid :public SolidFigure
//{
//public:
//	Cuboid(double width,double height,double high)
//		:_width(width)
//		, _height(height)
//		, _high(high)
//	{}
//	double getsuperficialArea()
//	{
//		return 2 * (_width * _height + _width * _high + _high * _height);
//	}
//	double getVolume()
//	{
//		return _width * _height * _high;
//	}
//	void showAll()
//	{
//		cout << getsuperficialArea() << endl;
//		cout << getVolume() << endl;
//	}
//private:
//	double _width;
//	double _height;
//	double _high;
//
//};
//int main()
//{
//	Cuboid st(2.2, 5.5, 6.6);
//	st.showAll();
//	return 0;
//}



//总结：这个是期末考试全部的大题，只有函数重载那里比较难，有一，两个题可能要背背。
//我反思了一下，认为错误概率比较高的：
//1.错误拼写；
//2.public:忘记写。
//3.传参没有用正确的方式传
//4.还有一点容易出错，时间一长，我可能就会忘记那个知识点怎么样，所以说还是要经常复盘才可以。
